package net.lab1024.sa.admin.module.business.erp.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import net.lab1024.sa.admin.module.business.erp.dao.*;
import net.lab1024.sa.admin.module.business.erp.domain.entity.*;
import net.lab1024.sa.admin.module.business.erp.domain.form.add.AccountAddForm;
import net.lab1024.sa.admin.module.business.erp.domain.form.query.AccountQueryForm;
import net.lab1024.sa.admin.module.business.erp.domain.form.update.AccountUpdateForm;
import net.lab1024.sa.admin.module.business.erp.domain.vo.AccountVO;
import net.lab1024.sa.base.common.code.UserErrorCode;
import net.lab1024.sa.base.common.domain.PageResult;
import net.lab1024.sa.base.common.domain.ResponseDTO;
import net.lab1024.sa.base.common.util.SmartBeanUtil;
import net.lab1024.sa.base.common.util.SmartPageUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;

/**
 * erp生产订单与对应表 Service
 *
 * @Author akita
 * @Date 2025-04-17 14:03:35
 * @Copyright 无
 */

@Service
public class AccountService {

    @Resource
    private AccountDao accountDao;
    @Resource
    private AccountaDao accountaDao;
    @Resource
    private AccountbDao accountbDao;
    @Resource
    private AccountcDao accountcDao;
    @Resource
    private MmordbDao mmordbDao;
    @Resource
    private MmordaDao mmordaDao;
    @Resource
    private NmmordaDao nmmordaDao;
    @Resource
    private CalendarsaDao calendarsaDao;
    @Resource
    private MmordDao mmordDao;
    @Resource
    private NmmordDao nmmordDao;
    @Resource
    private WageDao wageDao;

    /**
     * 分页查询
     */
    public PageResult<AccountVO> queryPage(AccountQueryForm queryForm) {
        Page<?> page = SmartPageUtil.convert2PageQuery(queryForm);
        List<AccountVO> list = accountDao.queryPage(page, queryForm);
        return SmartPageUtil.convert2PageResult(page, list);
    }

    /**
     * 添加
     */
    public ResponseDTO<Long> add(AccountAddForm addForm) {
        AccountEntity accountEntity = SmartBeanUtil.copy(addForm, AccountEntity.class);
        accountDao.insert(accountEntity);
        return ResponseDTO.ok(accountEntity.getDocEntry());
    }

    /**
     * 更新
     */
    public ResponseDTO<String> update(AccountUpdateForm updateForm) {
        AccountEntity accountEntity = SmartBeanUtil.copy(updateForm, AccountEntity.class);

        if (accountDao.updateById(accountEntity) == 0) {
            throw new RuntimeException("数据已被更新，刷新后重试！");
        }
        return ResponseDTO.ok();
    }

    /**
     * 批量删除
     */
    public ResponseDTO<String> batchDelete(List<Long> idList) {
        accountDao.deleteBatchIds(idList);
        return ResponseDTO.ok();
    }

    /**
     * 单个删除
     */

    @Transactional
    public ResponseDTO<String> delete(Long docEntry) {


        /*
         * 1、校验当月的工资单是否存在
         *
         *
         *
         * */

        AccountEntity accountEntity = accountDao.selectById(docEntry);
        WageEntity wageEntity = wageDao.selectOne(new LambdaQueryWrapper<WageEntity>().eq(WageEntity::getAbsId, accountEntity.getAbsId()));

        if (wageEntity != null) {
            return ResponseDTO.error(UserErrorCode.ALREADY_EXIST,"存在未删除的工资单！，请先删除工资单");

        }





        List<MmordEntity> mmordEntities = mmordDao.selectList(new LambdaQueryWrapper<MmordEntity>().eq(MmordEntity::getAbsId, accountEntity.getAbsId()));
        for (MmordEntity mmordEntity : mmordEntities) {
            mmordEntity.setDocStatus("O");
            mmordDao.updateById(mmordEntity);
        }
        List<NmmordEntity> nmmordEntities = nmmordDao.selectList(new LambdaQueryWrapper<NmmordEntity>().eq(NmmordEntity::getAbsId, accountEntity.getAbsId()));
        if (nmmordEntities != null && !nmmordEntities.isEmpty()) {
            for (NmmordEntity nmmordEntity : nmmordEntities) {
                nmmordEntity.setDocStatus("O");
                nmmordDao.updateById(nmmordEntity);
            }
        }

        accountDao.deleteById(docEntry);
        accountaDao.deleteById(docEntry);
        accountbDao.deleteById(docEntry);
        accountcDao.deleteById(docEntry);
        return ResponseDTO.ok();
    }

    public ResponseDTO<AccountEntity> info(Long docEntry) {
        AccountEntity accountEntity = accountDao.info(docEntry);
        accountEntity.setLista(accountaDao.selectList(new LambdaQueryWrapper<AccountaEntity>().eq(AccountaEntity::getDocEntry, docEntry)));
        accountEntity.setListb(accountbDao.selectList(new LambdaQueryWrapper<AccountbEntity>().eq(AccountbEntity::getDocEntry, docEntry)));
        accountEntity.setListc(accountcDao.selectList(new LambdaQueryWrapper<AccountcEntity>().eq(AccountcEntity::getDocEntry, docEntry)));
        return ResponseDTO.ok(accountEntity);
    }

    @Transactional
    public ResponseDTO<String> batchExcute(AccountQueryForm queryForm) {
        // 重置异常记录
        List<CalendarsaEntity> calendarsaEntities = calendarsaDao.selectList(new LambdaQueryWrapper<CalendarsaEntity>().eq(true, CalendarsaEntity::getAbsId, queryForm.getAbsId()));
        if (calendarsaEntities == null || calendarsaEntities.isEmpty()) {
            throw new RuntimeException("不存在当月日历！");
        }
        List<MmordbEntity> mmordbEntitiesa = mmordbDao.selectCount(queryForm.getAbsId());
        for (MmordbEntity mmordbEntity : mmordbEntitiesa) {
            for (MmordbEntity entity : mmordbDao.selectList(new LambdaQueryWrapper<MmordbEntity>().eq(MmordbEntity::getNowDate, mmordbEntity.getNowDate()).eq(MmordbEntity::getUserId, mmordbEntity.getUserId()))) {
                BigDecimal time1 = new BigDecimal(0);
                BigDecimal time2 = new BigDecimal(0);
                BigDecimal time3 = new BigDecimal(0);
                BigDecimal time4 = new BigDecimal(0);
                BigDecimal time5 = new BigDecimal(0);
                BigDecimal time6 = new BigDecimal(0);
                BigDecimal time7 = new BigDecimal(0);
                BigDecimal time8 = new BigDecimal(0);
                BigDecimal time9 = new BigDecimal(0);
                BigDecimal time10 = new BigDecimal(0);
                BigDecimal time11 = new BigDecimal(0);
                BigDecimal time12 = new BigDecimal(0);
                BigDecimal time13 = new BigDecimal(0);
                BigDecimal time14 = new BigDecimal(0);
                BigDecimal time15 = new BigDecimal(0);
                BigDecimal time16 = new BigDecimal(0);
                BigDecimal time17 = new BigDecimal(0);
                BigDecimal time18 = new BigDecimal(0);
                BigDecimal time19 = new BigDecimal(0);
                BigDecimal time20 = new BigDecimal(0);
                BigDecimal time21 = new BigDecimal(0);
                BigDecimal time22 = new BigDecimal(0);
                BigDecimal time23 = new BigDecimal(0);
                BigDecimal time24 = new BigDecimal(0);
                if (entity.getTime1()) {
                    time1 = time1.add(BigDecimal.ONE);
                }
                if (entity.getTime2()) {
                    time2 = time2.add(BigDecimal.ONE);
                }
                if (entity.getTime3()) {
                    time3 = time3.add(BigDecimal.ONE);
                }
                if (entity.getTime4()) {
                    time4 = time4.add(BigDecimal.ONE);
                }
                if (entity.getTime5()) {
                    time5 = time5.add(BigDecimal.ONE);
                }
                if (entity.getTime6()) {
                    time6 = time6.add(BigDecimal.ONE);
                }
                if (entity.getTime7()) {
                    time7 = time7.add(BigDecimal.ONE);
                }
                if (entity.getTime8()) {
                    time8 = time8.add(BigDecimal.ONE);
                }
                if (entity.getTime9()) {
                    time9 = time9.add(BigDecimal.ONE);
                }
                if (entity.getTime10()) {
                    time10 = time10.add(BigDecimal.ONE);
                }
                if (entity.getTime11()) {
                    time11 = time11.add(BigDecimal.ONE);
                }
                if (entity.getTime12()) {
                    time12 = time12.add(BigDecimal.ONE);
                }
                if (entity.getTime13()) {
                    time13 = time13.add(BigDecimal.ONE);
                }
                if (entity.getTime14()) {
                    time14 = time14.add(BigDecimal.ONE);
                }
                if (entity.getTime15()) {
                    time15 = time15.add(BigDecimal.ONE);
                }
                if (entity.getTime16()) {
                    time16 = time16.add(BigDecimal.ONE);
                }
                if (entity.getTime17()) {
                    time17 = time17.add(BigDecimal.ONE);
                }
                if (entity.getTime18()) {
                    time18 = time18.add(BigDecimal.ONE);
                }
                if (entity.getTime19()) {
                    time19 = time19.add(BigDecimal.ONE);
                }
                if (entity.getTime20()) {
                    time20 = time20.add(BigDecimal.ONE);
                }
                if (entity.getTime21()) {
                    time21 = time21.add(BigDecimal.ONE);
                }
                if (entity.getTime22()) {
                    time22 = time22.add(BigDecimal.ONE);
                }
                if (entity.getTime23()) {
                    time23 = time23.add(BigDecimal.ONE);
                }
                if (entity.getTime24()) {
                    time24 = time24.add(BigDecimal.ONE);
                }
                BigDecimal timeAll = time1.add(time2).add(time3).add(time4).add(time5).add(time6).add(time7).add(time8).add(time9).add(time10).add(time11).add(time12).add(time13).add(time14).add(time15).add(time16).add(time17).add(time18).add(time19).add(time20).add(time21).add(time22).add(time23).add(time24);
                entity.setWorkTime(BigDecimal.ZERO);
                entity.setOverTime(BigDecimal.ZERO);


                for (CalendarsaEntity child : calendarsaEntities) {
                    if (child.getNowDate().isEqual(entity.getNowDate())) {
                        if ("a".equals(child.getDel())) {
                            if (timeAll.compareTo(BigDecimal.valueOf(8)) >= 0) {
                                entity.setWorkTime(BigDecimal.valueOf(8));
                                entity.setCommon(timeAll.subtract(BigDecimal.valueOf(8)));
                            } else {
                                entity.setWorkTime(timeAll);
                            }
                            /*公休*/
                        } else if ("b".equals(child.getDel())) {
                            entity.setOverTime(timeAll);
                            /*节假*/
                        } else if ("c".equals(child.getDel())) {
                            entity.setHoliday(timeAll);

                        }
                        entity.setWeek(child.getWeek());
                        entity.setWorkDay(child.getWorkDay());
                        mmordbDao.update(entity, new LambdaQueryWrapper<MmordbEntity>().eq(MmordbEntity::getDocEntry, entity.getDocEntry()).eq(MmordbEntity::getLineNum, entity.getLineNum()));
                        break;
                    }
                }

            }
        }
        mmordbEntitiesa = mmordbDao.selectCount(queryForm.getAbsId());
        for (MmordbEntity mmordbEntity : mmordbEntitiesa) {
            for (MmordbEntity entity : mmordbDao.selectList(new LambdaQueryWrapper<MmordbEntity>().eq(MmordbEntity::getNowDate, mmordbEntity.getNowDate()).eq(MmordbEntity::getUserId, mmordbEntity.getUserId()))) {
                if (mmordbEntity.getWorkTimeTot().compareTo(BigDecimal.ZERO) != 0) {
                    entity.setWorkTime(mmordbEntity.getWorkTime().multiply(entity.getWorkTime().divide(mmordbEntity.getWorkTimeTot(), 4)));
                }
                if (mmordbEntity.getCommonTot().compareTo(BigDecimal.ZERO) != 0) {
                    entity.setCommon(mmordbEntity.getCommon().multiply(entity.getCommon().divide(mmordbEntity.getCommonTot(), 4)));
                }
                if (mmordbEntity.getOverTimeTot().compareTo(BigDecimal.ZERO) != 0) {
                    entity.setOverTime(mmordbEntity.getOverTime().multiply(entity.getOverTime().divide(mmordbEntity.getOverTimeTot(), 4)));
                }
                if (mmordbEntity.getHolidayTot().compareTo(BigDecimal.ZERO) != 0) {
                    entity.setHoliday(mmordbEntity.getHoliday().multiply(entity.getHoliday().divide(mmordbEntity.getHolidayTot(), 4)));
                }
                mmordbDao.update(entity, new LambdaQueryWrapper<MmordbEntity>().eq(MmordbEntity::getDocEntry, entity.getDocEntry()).eq(MmordbEntity::getLineNum, entity.getLineNum()));
            }
        }
        // 汇总设备数据
        List<AccountaEntity> accountaEntities = mmordaDao.selectCountAll(queryForm.getAbsId());
        int lineNum = 0;
        AccountaEntity accountaEntity1 = new AccountaEntity();
        for (AccountaEntity accountaEntity : accountaEntities) {
            lineNum++;
            accountaEntity1.setDocEntry(queryForm.getDocEntry());
            accountaEntity1.setLineNum(lineNum);
            accountaEntity1.setMacId(accountaEntity.getMacId());
            accountaEntity1.setMacName(accountaEntity.getMacName());
            accountaEntity1.setMacTime(accountaEntity.getMacTime());
            accountaEntity1.setMacCost(accountaEntity.getMacCost());
            accountaEntity1.setBaseEntry(accountaEntity.getDocEntry());
            accountaDao.insert(accountaEntity1);
        }
        List<AccountbEntity> accountbEntities = mmordbDao.selectCountAll(queryForm.getAbsId());
        int lineNuma = 0;
        AccountbEntity accountbEntity1 = new AccountbEntity();
        for (AccountbEntity accountbEntity : accountbEntities) {
            lineNuma++;
            accountbEntity1.setDocEntry(queryForm.getDocEntry());
            accountbEntity1.setLineNum(lineNuma);
            accountbEntity1.setUserId(accountbEntity.getUserId());
            accountbEntity1.setUserName(accountbEntity.getUserName());
            accountbEntity1.setNowDate(accountbEntity.getNowDate());
            accountbEntity1.setWorkTime(accountbEntity.getWorkTime());
            accountbEntity1.setCommon(accountbEntity.getCommon());
            accountbEntity1.setHoliday(accountbEntity.getHoliday());
            accountbEntity1.setHolidayCost(accountbEntity.getHolidayCost());
            accountbEntity1.setCommonCost(accountbEntity.getCommonCost());
            accountbEntity1.setWorkOverTime(accountbEntity.getWorkOverTime());
            accountbEntity1.setWorkOverCost(accountbEntity.getWorkOverCost());
            accountbEntity1.setDeduct(accountbEntity.getDeduct());
            accountbEntity1.setDeductCost(BigDecimal.ZERO);

            /* 扣除调休和旷工金额*/
            if (accountbEntity1.getDeduct().compareTo(BigDecimal.ZERO) != 0) {
                if (accountbEntity1.getHoliday().compareTo(accountbEntity.getDeduct()) >= 0) {
                    accountbEntity1.setDeductCost(accountbEntity.getDeduct().multiply(accountbEntity1.getHolidayCost().divide(accountbEntity1.getHoliday(), 4)));
                } else {
                    BigDecimal add = accountbEntity1.getHoliday().add(accountbEntity1.getWorkOverTime());
                    BigDecimal subtract = accountbEntity.getDeduct().subtract(accountbEntity.getHoliday());
                    if (add.compareTo(accountbEntity.getDeduct()) >= 0) {
                        accountbEntity1.setDeductCost(accountbEntity.getHolidayCost());
                        accountbEntity1.setDeductCost(accountbEntity1.getDeductCost().add(subtract.multiply(accountbEntity1.getWorkOverCost().divide(accountbEntity1.getWorkOverTime(), 4))));
                    } else {
                        BigDecimal add1 = accountbEntity1.getHoliday().add(accountbEntity1.getWorkOverTime()).add(accountbEntity1.getCommon());
                        BigDecimal subtract1 = accountbEntity.getDeduct().subtract(accountbEntity.getHoliday()).subtract(accountbEntity.getWorkOverTime());
                        if (add1.compareTo(subtract1) >= 0) {
                            accountbEntity1.setDeductCost(accountbEntity.getHolidayCost());
                            accountbEntity1.setDeductCost(accountbEntity1.getDeductCost().add(accountbEntity.getWorkOverCost()));
                            accountbEntity1.setDeductCost(accountbEntity1.getDeductCost().add(subtract1.multiply(accountbEntity1.getCommonCost().divide(accountbEntity.getCommon(), 4))));
                        } else {
                            BigDecimal add2 = accountbEntity1.getHoliday().add(accountbEntity1.getWorkOverTime()).add(accountbEntity1.getCommon()).add(accountbEntity1.getWorkTime());
                            BigDecimal subtract2 = accountbEntity.getDeduct().subtract(accountbEntity.getHoliday()).subtract(accountbEntity.getWorkOverTime()).subtract(accountbEntity.getCommon());
                            if (add2.compareTo(subtract2) >= 0) {
                                accountbEntity1.setDeductCost(accountbEntity.getHolidayCost());
                                accountbEntity1.setDeductCost(accountbEntity1.getDeductCost().add(accountbEntity.getWorkOverCost()));
                                accountbEntity1.setDeductCost(accountbEntity1.getDeductCost().add(accountbEntity.getCommonCost()));
                                accountbEntity1.setDeductCost(accountbEntity1.getDeductCost().add(subtract2.multiply(accountbEntity.getHourCost())));
                            } else {
                                throw new RuntimeException(String.format("员工%s工时异常", accountbEntity.getUserName()));
                            }

                        }

                    }
                }
            }
            accountbEntity1.setBaseEntry(accountbEntity.getBaseEntry());
            accountbDao.insert(accountbEntity1);
        }
        List<AccountbEntity> entityList = nmmordaDao.selectCountAll(queryForm.getAbsId());
        int lineNumb = 0;
        for (AccountbEntity accountbEntity : entityList) {
            AccountcEntity accountcEntity = new AccountcEntity();
            lineNumb++;
            accountcEntity.setDocEntry(queryForm.getDocEntry());
            accountcEntity.setLineNum(lineNumb);
            accountcEntity.setUserId(accountbEntity.getUserId());
            accountcEntity.setUserName(accountbEntity.getUserName());
            accountcEntity.setNowDate(accountbEntity.getNowDate());
            accountcEntity.setWorkTime(accountbEntity.getWorkTime());
            accountcEntity.setWorkOverTime(accountbEntity.getWorkOverTime());
            accountcEntity.setWorkOverCost(accountbEntity.getWorkOverCost());
            accountcEntity.setBaseEntry(accountbEntity.getBaseEntry());
            accountcEntity.setCommon(accountbEntity.getCommon());
            accountcEntity.setHoliday(accountbEntity.getHoliday());
            accountcEntity.setHolidayCost(accountbEntity.getHolidayCost());
            accountcEntity.setCommonCost(accountbEntity.getCommonCost());
            accountcEntity.setDeduct(accountbEntity.getDeduct());
            accountcEntity.setDeductCost(BigDecimal.ZERO);

            if (accountbEntity.getDeduct().compareTo(BigDecimal.ZERO) != 0) {
                if (accountcEntity.getHoliday().compareTo(accountbEntity.getDeduct()) >= 0) {
                    accountcEntity.setDeductCost(accountbEntity.getDeduct().multiply(accountcEntity.getHolidayCost().divide(accountcEntity.getHoliday(), 4)));
                } else {
                    BigDecimal add = accountcEntity.getHoliday().add(accountcEntity.getWorkOverTime());
                    BigDecimal subtract = accountbEntity.getDeduct().subtract(accountbEntity.getHoliday());
                    if (add.compareTo(accountbEntity.getDeduct()) >= 0) {
                        accountcEntity.setDeductCost(accountbEntity.getHolidayCost());
                        accountcEntity.setDeductCost(accountcEntity.getDeductCost().add(subtract.multiply(accountcEntity.getWorkOverCost().divide(accountcEntity.getWorkOverTime(), 4))));
                    } else {
                        BigDecimal add1 = accountcEntity.getHoliday().add(accountcEntity.getWorkOverTime()).add(accountcEntity.getCommon());
                        BigDecimal subtract1 = accountbEntity.getDeduct().subtract(accountbEntity.getHoliday()).subtract(accountbEntity.getWorkOverTime());
                        if (add1.compareTo(subtract1) >= 0) {
                            accountcEntity.setDeductCost(accountbEntity.getHolidayCost());
                            accountcEntity.setDeductCost(accountcEntity.getDeductCost().add(accountbEntity.getWorkOverCost()));
                            accountcEntity.setDeductCost(accountcEntity.getDeductCost().add(subtract1.multiply(accountcEntity.getCommonCost().divide(accountbEntity.getCommon(), 4))));
                        } else {
                            BigDecimal add2 = accountcEntity.getHoliday().add(accountcEntity.getWorkOverTime()).add(accountcEntity.getCommon()).add(accountcEntity.getWorkTime());
                            BigDecimal subtract2 = accountbEntity.getDeduct().subtract(accountbEntity.getHoliday()).subtract(accountbEntity.getWorkOverTime()).subtract(accountbEntity.getCommon());

                            accountcEntity.setDeductCost(accountbEntity.getHolidayCost());
                            accountcEntity.setDeductCost(accountcEntity.getDeductCost().add(accountbEntity.getWorkOverCost()));
                            accountcEntity.setDeductCost(accountcEntity.getDeductCost().add(accountbEntity.getCommonCost()));
                            accountcEntity.setDeductCost(accountcEntity.getDeductCost().add(subtract2.multiply(accountbEntity.getHourCost())));


                        }

                    }
                }
            }


            accountcDao.insert(accountcEntity);
        }
        /* 最后将工单关闭 */
        List<MmordEntity> mmordEntities = mmordDao.selectList(new LambdaQueryWrapper<MmordEntity>().eq(MmordEntity::getAbsId, queryForm.getAbsId()));
        if (mmordEntities != null && !mmordEntities.isEmpty()) {
            for (MmordEntity mmordEntity : mmordEntities) {
                mmordEntity.setDocStatus("C");
                mmordDao.updateById(mmordEntity);
            }
        }
        List<NmmordEntity> nmmordEntities = nmmordDao.selectList(new LambdaQueryWrapper<NmmordEntity>().eq(NmmordEntity::getAbsId, queryForm.getAbsId()));
        if (nmmordEntities != null && !nmmordEntities.isEmpty()) {
            for (NmmordEntity nmmordEntity : nmmordEntities) {
                nmmordEntity.setDocStatus("C");
                nmmordDao.updateById(nmmordEntity);
            }
        }
        return ResponseDTO.ok();
    }


    @Transactional
    public ResponseDTO<String> clear(Long docEntry) {
        AccountEntity accountEntity = accountDao.selectById(docEntry);
        WageEntity wageEntity = wageDao.selectOne(new LambdaQueryWrapper<WageEntity>().eq(WageEntity::getAbsId, accountEntity.getAbsId()));
        if (wageEntity != null) {
            return ResponseDTO.error(UserErrorCode.ALREADY_EXIST,"存在未删除的工资单！，请先删除工资单");

        }

        List<MmordEntity> mmordEntities = mmordDao.selectList(new LambdaQueryWrapper<MmordEntity>().eq(MmordEntity::getAbsId, accountEntity.getAbsId()));
        if (mmordEntities != null && !mmordEntities.isEmpty()) {
            for (MmordEntity mmordEntity : mmordEntities) {
                mmordEntity.setDocStatus("O");
                mmordDao.updateById(mmordEntity);
            }
        }

        List<NmmordEntity> nmmordEntities = nmmordDao.selectList(new LambdaQueryWrapper<NmmordEntity>().eq(NmmordEntity::getAbsId, accountEntity.getAbsId()));
        if (nmmordEntities != null && !nmmordEntities.isEmpty()) {
            for (NmmordEntity nmmordEntity : nmmordEntities) {
                nmmordEntity.setDocStatus("O");
                nmmordDao.updateById(nmmordEntity);
            }
        }
        accountaDao.deleteById(docEntry);
        accountbDao.deleteById(docEntry);
        accountcDao.deleteById(docEntry);
        return ResponseDTO.ok();
    }
}
